package com.hunlian.makelove.common;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;

/**
 * 日期处理类
 * @author jujun
 * 
 */
public class DateUtils {

	/**
	 * 获取本地长格式时间
	 * 
	 * @return 本地长格式时间,精确到秒
	 */
	public static String getLocalLongDate() {
		String dateString = "";
		SimpleDateFormat formatter = new SimpleDateFormat(
				"yyyy-MM-dd HH:mm:ss", Locale.CHINA);
		dateString = formatter.format(new Date());
		return dateString;
	}

	
	/**
	 * 获取本地长格式时间（14位）
	 * 
	 * @return 本地长格式时间,精确到秒
	 */
	public static String getLocalLongDate14() {
		String dateString = "";
		SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss",
				Locale.CHINESE);
		dateString = formatter.format(new Date());
		return dateString;
	}

	/**
	 * 获取本地短格式时间
	 * 
	 * @return 本地短格式时间
	 */
	public static String getLocalShortDate() {
		String dateString = "";
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd",
				Locale.CHINA);
		dateString = formatter.format(new Date());
		return dateString;
	}
	
	/**
	 * 获取2013-8-1类型的时间格式
	 * @return
	 * @author: Administrator
	 * @time: 2013-10-16下午1:31:28
	 */
	public static String getLocalShortSingleDate() {
		String dateString = "";
		SimpleDateFormat  sdf1=new SimpleDateFormat("yyyy-M-d");
		dateString = sdf1.format(new Date());
		return dateString;
	}

	
	/**
	 * 获取日期
	 * @param date
	 * @return;
	 */
	public static String getDateValue(Date date){
		if(date == null){
			return "";
		}
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		return formatter.format(date);
	}

	/**
	 * 获取本地自定义格式时间
	 * 
	 * @param format
	 *            自定义格式,如"yyyy-MM-dd HH:mm:ss"等
	 * @return 本地自定义格式时间
	 */
	public static String getLocalDefineDate(String format) {
		String dateString = "";
		SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.CHINA);
		dateString = formatter.format(new Date());
		return dateString;
	}

	/**
	 * 格式日期字串, 由""yyyy-MM-dd HH:mm:ss"格式变为"yyyyMMddHHmmss"格式/
	 * 
	 * @param path
	 * @return
	 */
	public static String formatDateString(String s) {
		if (s == null)
			return null;
		s = s.replaceAll("-", "");
		s = s.replaceAll(" ", "");
		s = s.replaceAll(":", "");
		return s;
	}

	/**
	 * 将 指定的字符串转化成Integer类
	 * 
	 * @param strValue
	 *            用于转化的字符串
	 * @return 转化成功返回一个Interger句柄，否则返回null
	 */
	public final static Integer getIntegerValue(String strValue) {
		if (null != strValue) {
			try {
				Integer numValue = Integer.valueOf(strValue);
				return numValue;
			} catch (NumberFormatException ex) {
			}
		}
		return null;
	}

	/**
	 * 将指定的字符串按照给的日期和时间格式转化成Date对象
	 * 
	 * @param patten
	 *            表示日期和时间的格式的字符串 例如: "yyyy-MM-dd HH:mm:ss"
	 *            请参考java.text.SimpleDateFormat类
	 * @param strDateTime
	 *            需要检验的字符串
	 * @return 成功则返回一个Date句柄，否则返回null 注：调用GregorianCalendar的setTime(Date
	 *         date)函数可将Date对象转化为 GregorianCalendar对象
	 */
	public final static Date getValidDateTime(String patten, String strDateTime) {
		if (null != strDateTime) {
			SimpleDateFormat formatter = new SimpleDateFormat(patten);
			try {
				Date date = (Date) formatter.parse(strDateTime);
				return date;
			} catch (ParseException e) {
			}
		}
		return null;
	}

	/**
	 * 
	 * @param strDate
	 *            日期字符串，譬如"2002-3-20"
	 * @param strHour
	 *            小时字符串，譬如"3"
	 * @param strMinute
	 *            分钟字符串，譬如"30"
	 * @return 返回由strDate、strHour、strMinute指定时间的GregorianCalendar对象("2002-3-20
	 *         3: 30")
	 */
	public final static GregorianCalendar getCalendar(String strDate,
			String strHour, String strMinute) {
		String patten = "yyyy-MM-dd HH:mm:ss";
		String strFullDate = strDate.trim() + " " + strHour.trim() + ":"
				+ strMinute.trim() + ":00";
		Date date = getValidDateTime(patten, strFullDate);
		if (null != date) {
			GregorianCalendar calendar = new GregorianCalendar();
			calendar.setTime(date);
			return calendar;
		} else
			return null;
	}

	public final static GregorianCalendar getShortCalendar(String strDate) {
		String patten = "yyyy-MM-dd";
		String strFullDate = strDate.trim();
		Date date = getValidDateTime(patten, strFullDate);
		if (null != date) {
			GregorianCalendar calendar = new GregorianCalendar();
			calendar.setTime(date);
			return calendar;
		} else
			return null;
	}

	/**
	 * 
	 * @param calendar
	 *            GregorianCalendar对象
	 * @return 返回将GregorianCalendar所表示的时间解析后生成的字符串数组，数组大小为
	 *         3，第一个字符串为日期，第二个字符串为小时，第三个字符串为分钟 譬如calendar的当前时间为"2002-3-20
	 *         3:30:00",则返回String[]＝{"2002-3-20","3","20"}
	 */
	public final static String[] getDateTimeStrings(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = new String[3];
			times[0] = String.valueOf(calendar.get(Calendar.YEAR)) + "-"
					+ String.valueOf(calendar.get(Calendar.MONTH) + 1) + "-"
					+ String.valueOf(calendar.get(Calendar.DAY_OF_MONTH));

			times[1] = String.valueOf(calendar.get(Calendar.HOUR_OF_DAY));
			times[2] = String.valueOf(calendar.get(Calendar.MINUTE));
			return times;
		} else
			return null;
	}

	/**
	 * 根据给定的GregorianCalendar对象得到其指定的时间的字符串表示 (Year-Month-Day Hour:Minute)
	 * 
	 * @param calendar
	 *            给定的GregorianCalendar对象
	 * @return calendar所指定时间的字符串表示
	 */
	public final static String getDateFullString(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = getDateTimeStrings(calendar);
			if (times[1].length() == 1) // wsp
				times[1] = "0" + times[1];
			if (times[2].length() == 1)
				times[2] = "0" + times[2];
			return times[0] + " " + times[1] + ":" + times[2];
		} else
			return null;
	}

	/**
	 * 根据给定的GregorianCalendar对象得到其指定的时间的字符串表示 (Year-Month-Day Hour:Minute)
	 * 
	 * @param date
	 *            给定的date对象
	 * @return calendar所指定时间的字符串表示
	 */
	public final static String getDateFullString(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return getDateFullString(calendar);
	}

	public static GregorianCalendar getCalendar(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return calendar;
	}

	/**
	 * 根据给定的GregorianCalendar对象得到其指定的时间的字符串表示 (Year-Month-Day Hour:Minute)
	 * 
	 * @param calendar
	 *            给定的GregorianCalendar对象
	 * @return calendar所指定时间的字符串表示
	 */
	public final static String getDateWeekFullString(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = getDateTimeStrings(calendar);
			return times[0] + " " + times[1] + ":" + times[2];
		} else
			return null;
	}

	/**
	 * 根据给定的GregorianCalendar对象得到其指定的只包含时间的字符串表示 (Hour:Minute)
	 * 
	 * @param calendar
	 *            给定的GregorianCalendar对象
	 * @return 只包含时间的字符串
	 */
	public final static String getTimeFullString(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = getDateTimeStrings(calendar);
			return times[1] + ":" + times[2];
		} else
			return null;
	}

	/**
	 * 根据给定的GregorianCalendar对象得到其指定的日期的字符串表示 (Year-Month-Day )
	 * 
	 * @param calendar
	 *            给定的GregorianCalendar对象
	 * @return calendar所指定时间的日期的字符串表示
	 */
	public final static String getDateString(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = splitDatetime(calendar);
			return times[0] + "-" + times[1] + "-" + times[2];
		} else
			return null;
	}

	public final static String getDateString(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return getDateString(calendar);
	}

	public final static String getDayOfWeekMsg(int dayNO) {
		switch (dayNO) {
		case 1:
			return "label.weekSunday";
		case 2:
			return "label.weekMonday";
		case 3:
			return "label.weekTuesday";
		case 4:
			return "label.weekWednesday";
		case 5:
			return "label.weekThursday";
		case 6:
			return "label.weekFriday";
		case 7:
			return "label.weekSaturday";
		default:
			return null;
		}
	}

	/**
	 * 按ch的值分解字符串str，把分解后的子字符串置入一个字符数组，如果str中不包含ch字符串，则返回数组的第一个元素为这个字符串str
	 * 例如：splitStr("12:24:30",':') 则结果为{"12","24","30"}<br>
	 * String[] test = splitStr("TestStr",'A') 则test[0]="TestStr"
	 * 
	 * @param str
	 *            被分解的字符串
	 * @param ch
	 *            作为分割标准的字符
	 * @return 返回分解后的字符串数组
	 * 
	 * @author 王晖
	 */
	public final static String[] splitStr(String str, int ch) {
		String[] splitted = new String[100]; // 这个数值100应该修改

		String innerStr = str;

		int pos, i = 0;
		do {
			pos = innerStr.indexOf(ch);
			if (pos == -1)
				splitted[i] = innerStr;
			else {
				splitted[i] = new String(innerStr.toCharArray(), 0, pos);
				innerStr = String.copyValueOf(innerStr.toCharArray(), pos + 1,
						innerStr.length() - pos - 1);
				i = i + 1;
			}
		} while (pos != -1);
		return splitted;
	}

	/**
	 * 获取某个日期所在的那个星期的第一天的最开始时刻
	 * 
	 * @param date
	 *            日期
	 * @return 那个星期的第一天的开始时刻
	 */
	public final static Date getWeekStart(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
		setDayStart(calendar);
		return calendar.getTime();
	}

	/**
	 * 获取某个日期所在的那个星期的最后一天的最后时刻
	 * 
	 * @param date
	 *            日期
	 * @return 那个星期的第一天的最后时刻
	 */
	public final static Date getWeekEnd(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
		setDayEnd(calendar);
		return calendar.getTime();
	}

	/**
	 * 获取某个日期所在那一天的最开始时刻
	 * 
	 * @param date
	 *            日期
	 * @return 那一天的开始时刻
	 */
	public final static Date getDayStart(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		setDayStart(calendar);
		return calendar.getTime();
	}

	/**
	 * 获取某个日期所在那一天的最后时刻
	 * 
	 * @param date
	 *            日期
	 * @return 那一天的最后时刻
	 */
	public final static Date getDayEnd(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		setDayEnd(calendar);
		return calendar.getTime();
	}

	/**
	 * 根据日期，获取当月最开始的一天
	 * 
	 * @param date
	 *            日期
	 * @return 所在月的第一天
	 */
	public final static Date getMonthStart(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		setDayStart(calendar);
		return calendar.getTime();
	}

	/**
	 * 根据日期，获取当月最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 所在月的最后一天
	 */
	public final static Date getMonthEnd(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		calendar.add(Calendar.MONTH, 1);
		setDayEnd(calendar);
		calendar.add(Calendar.DATE, -1);
		return calendar.getTime();
	}

	/**
	 * 设置年
	 * 
	 * @param date
	 *            日期
	 * @param year
	 *            年数
	 * @return 得到的时间
	 */
	public final static Date setYear(Date date, int year) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.set(Calendar.YEAR, year);
		return calendar.getTime();
	}

	/**
	 * 设置时间为一天开始
	 * 
	 * @param calendar
	 *            日期
	 */
	private final static void setDayStart(Calendar calendar) {
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
	}

	/**
	 * 设置时间为一天结束
	 * 
	 * @param calendar
	 *            日期
	 */
	private final static void setDayEnd(Calendar calendar) {
		calendar.set(Calendar.HOUR_OF_DAY, 23);
		calendar.set(Calendar.MINUTE, 59);
		calendar.set(Calendar.SECOND, 59);
	}

	/**
	 * 获取某个日期相对的日期
	 * 
	 * @param date
	 *            日期
	 * @param relativeDay
	 *            相对天数
	 * @return 相对日期
	 * @author 李海华
	 */
	public static final Date getRelativeDate(Date date, int relativeDay) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, relativeDay);
		setDayStart(calendar);
		return calendar.getTime();

	}

	/**
	 * 以字符串数组的形式返回日期的各字段(年/月/日/时/分/秒/毫秒)的值
	 * 
	 * @param calendar
	 *            欲转换的时间
	 * @return 包括日期各字段的字符串值得字符串数组：times[0]=年/time[1]=月/time[2]=日/time[3]=时/time[4]=分/time[5]=秒/time[6]=毫秒
	 * @author 王晖
	 */
	public static String[] splitDatetime(GregorianCalendar calendar) {
		if (null != calendar) {
			String[] times = new String[7];
			times[0] = String.valueOf(calendar.get(Calendar.YEAR));
			times[1] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.MONTH) + 101).toCharArray(), 1, 2);
			times[2] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.DAY_OF_MONTH) + 100).toCharArray(),
					1, 2);
			times[3] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.HOUR_OF_DAY) + 100).toCharArray(), 1,
					2);
			times[4] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.MINUTE) + 100).toCharArray(), 1, 2);
			times[5] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.SECOND) + 100).toCharArray(), 1, 2);
			times[6] = String.copyValueOf(String.valueOf(
					calendar.get(Calendar.MILLISECOND) + 10000).toCharArray(),
					1, 4);
			return times;
		} else
			return null;
	}

	/**
	 * 以字符串数组的形式返回日期的各字段(年/月/日/时/分/秒/毫秒)的值
	 * 
	 * @param date
	 *            欲转换的时间
	 * @return 包括日期各字段的字符串值得字符串数组：times[0]=年/time[1]=月/time[2]=日/time[3]=时/time[4]=分/time[5]=秒/time[6]=毫秒
	 * @author 王晖
	 */
	public static String[] splitDatetime(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return splitDatetime(calendar);
	}

	/**
	 * 把时间转换为一定格式的日期字符串。
	 * 
	 * @param calendar
	 *            欲转换的时间
	 * @return 生成的日期
	 * @author 王晖
	 */
	public static String getDateStr(GregorianCalendar calendar) {
		String timeStr[] = splitDatetime(calendar);

		String returnStr = "";
		returnStr = timeStr[0] + "-" + timeStr[1] + "-" + timeStr[2] + " "
				+ timeStr[3] + ":" + timeStr[4] + ":" + timeStr[5];

		return returnStr;
	}

	/**
	 * 把时间转换为一定格式的日期字符串。
	 * 
	 * @param date
	 *            欲转换的时间
	 * @return 生成的日期
	 * @author 王晖
	 */
	public static String getDateStr(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return getDateStr(calendar);
	}

	/**
	 * 把时间转换为一定格式的时间字符串
	 * 
	 * @param calendar
	 *            欲转换的时间
	 * @return 生成的时间字符串
	 * @author 王晖
	 */
	public static String getTimeStr(GregorianCalendar calendar) {
		String timeStr[] = splitDatetime(calendar);

		String returnStr = "";
		returnStr = timeStr[3] + ":" + timeStr[4] + ":" + timeStr[5] + "."
				+ timeStr[6];

		return returnStr;
	}

	/**
	 * 把时间转换为一定格式的时间字符串。
	 * 
	 * @param date
	 *            欲转换的时间
	 * @return 生成的时间字符串
	 * @author 王晖
	 */
	public static String getTimeStr(Date date) {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return getTimeStr(calendar);
	}

	/**
	 * 判断两个时间字符串的前后关系
	 * 
	 * @param time1
	 *            时间参数1
	 * @param time2
	 *            时间参数2
	 * @return 如果时间参数1在时间参数2前面，返回-1,在后面返回1, 相等，返回1
	 */
	public static int compare(String time1, String time2) {
		Date d1 = DateUtils.getValidDateTime("yyyy-MM-dd HH:mm:ss",
				time1);
		Date d2 = DateUtils.getValidDateTime("yyyy-MM-dd HH:mm:ss",
				time2);

		if (d1 == null && d2 == null)
			return 0;
		if (d1 == null && d2 != null)
			return -1;
		if (d1 != null && d2 == null)
			return 1;
		if (d1.equals(d2))
			return 0;
		if (d1.after(d2))
			return 1;
		else
			return -1;
	}

	/**
	 * 计算总耗时
	 * 
	 * @param starttime
	 * @param endtime
	 * @return totoaltime
	 */
	public long caculateTime(Timestamp starttime, Timestamp endtime) {
		long result;
		result = ((Date) endtime).getTime() - ((Date) starttime).getTime();
		return result;
	}

	/**
	 * 使用结束日期减去开始日期,得到相差的天数
	 * @param date
	 * @return
	 */
	public static int subDate(Date starttime,Date endtime) {
	    if(starttime==null || endtime==null){
	        return 0;
	    }
		long temp = endtime.getTime() - starttime.getTime();
		if (temp > 0) {
			return (int) (temp / (24 * 60 * 60 * 1000));
		} else {
			return (int) (temp / (24 * 60 * 60 * 1000)) - 1;
		}
	}
	
	/**
     * 使用输入的日期减去标准日期,得到相差的天数
     * @param date
     * @return
     */
    public static int subDate(Date date) {
        Date now = new Date();
        long temp = now.getTime() - date.getTime();
        if (temp > 0) {
            return (int) (temp / (24 * 60 * 60 * 1000));
        } else {
            return (int) (temp / (24 * 60 * 60 * 1000)) - 1;
        }
    }

    /**
     * 根据日期，获取下月最开始的一天
     * 
     * @param date
     *            日期
     * @return 所在月的第一天
     */
    public final static Date getLastMonthStart(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.MONTH, 1);
        setDayStart(calendar);
        return calendar.getTime();
    }

    /**
     * 根据日期，获取当年最开始的一天
     * 
     * @param date
     *            日期
     * @return 所在月的第一天
     */
    public final static Date getYearStart(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_YEAR, 1);
        setDayStart(calendar);
        return calendar.getTime();
    }

    /**
     * 根据日期，获取下年最开始的一天
     * 
     * @param date
     *            日期
     * @return 所在月的第一天
     */
    public final static Date getLastYearStart(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_YEAR, 1);
        calendar.add(Calendar.YEAR, 1);
        setDayStart(calendar);
        return calendar.getTime();
    }

    /**
     * 根据日期，获取上月最开始的一天
     * 
     * @param date
     *            日期
     * @return 所在月的第一天
     */
    public final static Date getPrevMonthStart(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.MONTH, -1);
        setDayStart(calendar);
        return calendar.getTime();
    }
    
    /**
	 * 获取日期
	 * @param endDate	必须是 2012-12-12 或者 2012-01-01 格式的日期
	 * @param format	日期的格式
	 */
	public static Date getLocalShortDate(String endDate, String format) {
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date date = dateFormat.parse(endDate);
			return date;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	// 返回当月天数
	public int getDays(int year, int month)

		{

			int days;

			int FebDay = 28;

			if (isLeap(year))

				FebDay = 29;

			switch (month)

			{

			case 1:

			case 3:

			case 5:

			case 7:

			case 8:

			case 10:

			case 12:

				days = 31;

				break;

			case 4:

			case 6:

			case 9:

			case 11:

				days = 30;

				break;

			case 2:

				days = FebDay;

				break;

			default:

				days = 0;

				break;

			}

			return days;

		}
		
		// 判断闰年
		boolean isLeap(int year)

		{

			if (((year % 100 == 0) && year % 400 == 0)
					|| ((year % 100 != 0) && year % 4 == 0))

				return true;

			else

				return false;

		}
		
		// 返回当前年份
		public int getYear()
		{
			Date date = new Date();

			String year = new SimpleDateFormat("yyyy").format(date);

			return Integer.parseInt(year);
		}

		// 返回当前月份
		public int getMonth()
		{

			Date date = new Date();

			String month = new SimpleDateFormat("MM").format(date);

			return Integer.parseInt(month);
		}
		
		
		/**
		 * 获取当月第一天的日期
		 * @return
		 * @author: zj
		 * @time: 2013-11-19下午5:05:16
		 */
		public static String getCurMonthFirstDay(){
			DateUtils du = new DateUtils();
			return du.getYear()+"-"+du.getMonth()
			+"-"+"01";
		}
		
		/**
		 * 获取当月最后一天的日期
		 * @return
		 * @author: zj
		 * @time: 2013-11-19下午5:05:35
		 */
		public static String getCurMonthLastDay(){
			DateUtils du = new DateUtils();
			int days = du.getDays(du.getYear(), du.getMonth());
			return du.getYear()+"-"+du.getMonth()
			+"-"+days;
		}
}
